home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / IDLIncludes / MixedMode.idl < prev    next >
Text File  |  1996-05-01  |  9KB  |  221 lines
  1. /*
  2.      File:        MixedMode.idl
  3.  
  4.      Contains:    Mixed Mode Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. */
  18. #ifndef __MIXEDMODE_IDL__
  19. #define __MIXEDMODE_IDL__
  20.  
  21. #include <somobj.idl>
  22. #include <somcls.idl>
  23.  
  24. #ifndef __TYPES_IDL__
  25. #include <Types.idl>
  26. #endif
  27.  
  28. #ifdef __SOMIDL__
  29.  
  30. #if FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE
  31. /* Mixed Mode constants */
  32. /* Current Routine Descriptor Version */
  33. /* MixedModeMagic Magic Cookie/Trap number */
  34. /* Calling Conventions */
  35. typedef unsigned short            CallingConventionType;
  36.  
  37. /* ISA Types */
  38. typedef SInt8                    ISAType;
  39.  
  40. /* RTA Types */
  41. typedef SInt8                    RTAType;
  42.  
  43. /* Constants for specifing 68k registers */
  44. typedef unsigned short            registerSelectorType;
  45.  
  46. /* SizeCodes we use everywhere */
  47. /* Mixed Mode Routine Records */
  48. typedef unsigned long            ProcInfoType;
  49.  
  50. /* Routine Flag Bits */
  51. typedef unsigned short            RoutineFlagsType;
  52.  
  53. #endif
  54. #if FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE
  55. typedef SOMLargeStruct            RoutineRecord;                /* Derived from a struct of 20 bytes in size */
  56.  
  57. typedef OpaquePtr                RoutineRecordPtr;            /* Substituted OpaquePtr for ``RoutineRecord*'' */
  58.  
  59. typedef OpaquePtr                RoutineRecordHandle;        /* Substituted OpaquePtr for ``RoutineRecordPtr*'' */
  60.  
  61. /* Mixed Mode Routine Descriptors */
  62. /* Definitions of the Routine Descriptor Flag Bits */
  63. typedef UInt8                    RDFlagsType;
  64.  
  65. /* Routine Descriptor Structure */
  66. typedef SOMLargeStruct            RoutineDescriptor;            /* Derived from a struct of 32 bytes in size */
  67.  
  68. typedef OpaquePtr                RoutineDescriptorPtr;        /* Substituted OpaquePtr for ``RoutineDescriptor*'' */
  69.  
  70. typedef OpaquePtr                RoutineDescriptorHandle;    /* Substituted OpaquePtr for ``RoutineDescriptorPtr*'' */
  71.  
  72. #endif
  73. #if FOR_SYSTEM7_AND_SYSTEM8_DEPRECATED
  74. #endif
  75. #if FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE
  76. /* Mixed Mode ProcInfos */
  77. #endif
  78. #if FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE
  79. /*
  80.     NOTES ON USING ROUTINE DESCRIPTOR FUNCTIONS
  81.     
  82.     When calling these routine from classic 68k code there are two possible intentions.
  83.  
  84.     The first is source compatibility with code ported to CFM (either PowerPC or 68k CFM). When
  85.     the code is compiled for CFM the functions create routine descriptors that can be used by
  86.     the mixed mode manager operating on that machine. When the code is compiled for classic 68k
  87.     these functions do nothing so that the code will run on Macintoshes that do not have a
  88.     mixed mode manager. The dual nature of these functions is achieved by turning the CFM calls
  89.     into "no-op" macros for classic 68k: You can put "NewRoutineDescriptor" in your source,
  90.     compile it for any runtime or instruction set architecture, and it will run correctly on the
  91.     intended runtime/instruction platform. All without source changes and/or conditional source.
  92.     
  93.     The other intention is for code that "knows" that it is executing as classic 68k runtime
  94.     and is specifically trying to call code of another architecture using mixed mode. Since the
  95.     routines were designed with classic <-> CFM source compatibility in mind this second case
  96.     is treated special. For classic 68k code to create routines descriptors for use by mixed mode
  97.     it must call the "Trap" versions of the routines (NewRoutineDescriptorTrap). These versions
  98.     are only available to classic 68k callers: rigging the interfaces to allow calling them
  99.     from CFM code will result in runtime failure because no shared library implements or exports
  100.     the functions.
  101.     
  102.  
  103.     This almost appears seamless until you consider "fat" routine descriptors and the advent of
  104.     CFM-68K. What does "fat" mean? CFM-68K is not emulated on PowerPC and PowerPC is not emulated
  105.     on CFM-68K. It makes no sense to create a routine descriptor having both a CFM-68K routine
  106.     and a PowerPC native routine pointer. Therefore "fat" is defined to be a mix of classic and
  107.     CFM for the hardware's native instruction set: on PowerPC fat is classic and PowerPC native,
  108.     on a 68k machine with CFM-68K installed fat is classic and CFM-68K.
  109.     
  110.     By definition fat routine descriptors are only constructed by code that is aware of the 
  111.     architecture it is executing as and that another architecture exists. Source compatibility
  112.     between code intented as pure classic and pure CFM is not an issue and so NewFatRoutineDescriptor
  113.     is not available when building pure classic code.
  114.     
  115.     NewFatRoutineDescriptorTrap is available to classic code on both PowerPC and CFM-68K. The
  116.     classic code can use the code fragment manager routine "FindSymbol" to obtain the address of 
  117.     a routine in a shared library and then construct a routine descriptor with both the CFM routine 
  118.     and classic    routine.
  119. */
  120. #if GENERATINGCFM
  121. #else
  122. /* Note that the call to NewFatRoutineDescriptor is undefined when GENERATINGCFM is false. */
  123. #endif
  124. #if GENERATINGCFM
  125. /*
  126.  CallUniversalProc is only implemented in shared libraries on 68k and PowerPC, it is now
  127.  conditionalize with GENERATINGCFM.  This will catch accidental calls from classic 68K code
  128.  that previously only showed up as linker errors.
  129. */
  130. #endif
  131. #endif
  132. /* Macros for building ProcInfos */
  133. /*
  134.  * * * * * * * * * * * * * * 
  135.  *    SIZE_CODE -     Return the size code for an object, given its size in bytes.
  136.  *        size - size of an object in bytes
  137. */
  138. /*
  139.  * * * * * * * * * * * * * * 
  140.  *    RESULT_SIZE -     Return the result field of a ProcInfo, given the return object's size.
  141.  *                     This is the same for all ProcInfos
  142.  *        sizeCode - size code
  143. */
  144. /*
  145.  * * * * * * * * * * * * * * 
  146.  *    STACK_ROUTINE_PARAMETER -    Return a parameter field of a ProcInfo, for a simple,
  147.  *                                non-dispatched, stack based routine.
  148.  *        whichParam - which parameter
  149.  *        sizeCode - size code
  150. */
  151. /*
  152.  * * * * * * * * * * * * * * 
  153.  *    DISPATCHED_STACK_ROUTINE_PARAMETER -    Return a parameter field of a ProcInfo, for 
  154.  *                                            a dispatched, stack based routine.  The same
  155.  *                                            macro is used regardless of the type of
  156.  *                                            dispatching.
  157.  *        whichParam - which parameter
  158.  *        sizeCode - size code
  159. */
  160. /*
  161.  * * * * * * * * * * * * * * 
  162.  *    DISPATCHED_STACK_ROUTINE_SELECTOR_SIZE -    Return a the selector size field of a ProcInfo
  163.  *                                                for a dispatched, stack based routine.  The
  164.  *                                                same macro is used regardless of the type of
  165.  *                                                dispatching.
  166.  *        sizeCode - size code 
  167. */
  168. /*
  169.  * * * * * * * * * * * * * * 
  170.  *    REGISTER_RESULT_LOCATION -        Return the Result Location field of a ProcInfo, 
  171.  *                                    given the location.
  172.  *        whichReg - which register
  173. */
  174. /*
  175.  * * * * * * * * * * * * * * 
  176.  *    REGISTER_ROUTINE_PARAMETER -    Return a parameter field of a ProcInfo for a 
  177.  *                                    register based routine.
  178. */
  179. /*
  180.  * * * * * * * * * * * * * * 
  181.  *
  182.  *    SPECIAL_CASE_PROCINFO -     Returns the procInfo constant for the following special cases:
  183.  *    
  184.  *        High Hook & Caret Hook -  (see I-379)
  185.  *            C calling conventions, Rect on stack, pointer in A3, no return value
  186.  *        EOL Hook - (see VI-15-26)
  187.  *            Register-based; inputs in D0, A3, A4; 
  188.  *            output is Z flag of status register
  189.  *        Width Hook - (see VI-15-27)
  190.  *            Register-based; inputs in D0, D1, A0, A3, A4; output in D1 
  191.  *        NWidth Hook - (see VI-15-27)
  192.  *            Register-based; inputs in D0, D1, D2, A0, A2, A3, A4; output in D1 
  193.  *        TextWidthHook - (see VI-15-28)
  194.  *            Register-based; inputs in D0, D1, A0, A3, A4; output in D1 
  195.  *        DrawHook - (see VI-15-28)
  196.  *            Register-based; inputs in D0, D1, A0, A3, A4; no output
  197.  *        HitTestHook - (See VI-15-29)
  198.  *            Register-based; inputs in D0, D1, D2, A0, A3, A4; outputs in D0, D1, D2
  199.  *        FindWord -  (see VI-15-30)
  200.  *            Register-based; inputs in D0, D2, A3, A4; outputs in D0, D1
  201.  *        ADBRoutines - (see V-371)
  202.  *            Register-based; inputs in A0, A1, A2, D0; no outputs
  203.  *        ProtocolHandler - (see II-326)
  204.  *            Register-based; inputs in A0, A1, A2, A3, A4, D1.w; output in Z 
  205.  *        SocketListener - (see II-329)
  206.  *            Register-based; inputs in A0, A1, A2, A3, A4, D0.b, D1.w; output in Z 
  207.  *        Reclac - (see I-391)
  208.  *            Register-based; inputs in A3, D7; outputs in D2, D3, D4
  209.  *        DoText - (see I-391)
  210.  *            Register-based; inputs in A3, D3, D4, D7; outputs in A0, D0
  211.  *        GNEFilterProc - (see tech note 85)
  212.  *            Register & Stack Based; inputs in A1, D0 & on the stack; outputs on the stack
  213.  *        MenuBarHook - (see I-356)
  214.  *            Register & Stack Based; input on the stack; output in D0
  215. */
  216.  
  217. #endif /* __SOMIDL__ */
  218.  
  219. #endif /* __MIXEDMODE_IDL__ */
  220.  
  221.